Text Mining 'Anotaciones Agro'

#!python -m spacy download es_core_news_sm

import pandas as pd
import matplotlib.pyplot as plt
import re
from unidecode import unidecode
from wordcloud import WordCloud

pd.set_option('display.max_columns', None)
#pd.set_option('display.max_rows', None)

# Podemos ejecutar la notebook con una muestra aleatoria de 1000 comentarios
# Si es True la notebook es ejecutada con la muestra de comentarios
# Si es False la notebook es ejecutada con todos los comentarios
RUN_WITH_SAMPLE = False

# Definir si vamos a guardar o no las salidas de la notebook
SAVE_NOTEBOOK_RESULTS = False

# Nombre del detaset etiquetado a partir de los comentarios
file_with_tags = "Workflow_output/annotations_processed.csv"

# Importamos archivo csv
annotations = pd.read_csv('../data/annotations.csv')
annotations.head(5)

# volumen de comentarios
num_annotations = annotations.shape[0]
null_count = annotations['comments'].isnull().sum()
non_null_count = annotations['comments'].notnull().sum()


print("Cantidad de comentarios:", num_annotations)
print("Comentarios 'Nulos':", null_count)
print("Comentarios 'No nulos':", non_null_count)

# distribución de las etiquetas asignadas a los comentarios
annotations['annotation_tags'].value_counts(dropna=False,normalize=True)

# Exploración de comentarios
# Ejemplo de algunos comentarios que fueron asignados a la etiqueta 'maleza' y contienen el sstring 'no'
condicion = (annotations['annotation_tags']=='tags_general_weeds') & (annotations['comments'].str.contains('no'))
annotations[condicion].head()

# Extraemos una muestra de la basepara agilizar ejecución de la notebook
# Posteriormente tomaremos la base completa
annotations_full = annotations.copy()

# Tomamos muestra aleatoria de 1000 comentarios para testear su ejecución
if RUN_WITH_SAMPLE:
    annotations = annotations.sample(1000, random_state=42)

# Eliminamos comentarios nulos
annotations = annotations.dropna(subset=['comments'])

# Definimos función para limpieza de texto
def limpiar_texto(texto):
    # Convierte el texto a minúsculas
    texto = str(texto)
    texto = texto.lower()
    # Elimina tildes y caracteres especiales
    texto = unidecode(texto)
    # Elimina espacios en blanco al inicio y al final
    texto = texto.strip()
    # Elimina signos de puntuación y otros caracteres no deseados
    texto = re.sub(r'[^a-zA-Z0-9\s/]', '', texto)
    # Elimina múltiples espacios en blanco y los convierte en uno solo
    texto = re.sub(r'\s+', ' ', texto)
    # Devuelve el texto filtrado
    return texto

# Aplicamos limpieza del texto - No pisamos campo original sino que creamos uno nuevo
annotations['comments_clean'] = annotations['comments'].apply(limpiar_texto)

# Comparamos el comentario original con el 'limpio'
annotations[['comments', 'comments_clean']].sample(10, random_state=42)

# Cantidad de caracteres de los comentarios limpios
annotations["len_comments_clean"] = annotations["comments_clean"].str.len()

# Check comportamiento
annotations["len_comments_clean"].value_counts(dropna=False)

# Limpiamos comentarios sin caracteres
annotations = annotations[annotations["len_comments_clean"]>0].reset_index(drop=True).copy()

# TODO: mover importacion de librerias
import re
from unidecode import unidecode
import spacy
import nltk
from nltk.corpus import stopwords

# Cargar modelo en español de spaCy
nlp = spacy.load('es_core_news_sm')

# Descargar stop words de nltk en español
nltk.download('stopwords')

# Crear lista personalizada de stop words
custom_stop_words = set(unidecode(texto) for texto in stopwords.words('spanish')) - {'no', 'sin', 'con', 'pero', 'hay'}

# Tokenizar y eliminar stop words personalizadas usando spaCy
def limpiar_texto(texto):
    # Convierte el texto a minúsculas
    texto = str(texto).lower()
    # Elimina tildes y caracteres especiales
    texto = unidecode(texto)
    # Elimina espacios en blanco al inicio y al final
    texto = texto.strip()
    # Elimina signos de puntuación y otros caracteres no deseados
    texto = re.sub(r'[^a-zA-Z0-9\s/]', '', texto)
    # Elimina múltiples espacios en blanco y los convierte en uno solo
    texto = re.sub(r'\s+', ' ', texto)
    
    # Procesar el texto con spaCy
    doc = nlp(texto)
    
    # Filtrar palabras irrelevantes (stop words) y solo conservar las alfabéticas
    palabras_filtradas = [token.text for token in doc if token.text not in custom_stop_words and token.is_alpha]
    
    # Devuelve el texto filtrado
    return ' '.join(palabras_filtradas)


# Aplicar la función limpiar_texto a la columna 'comments' y crear la columna 'comments_clean'
annotations['comments_clean_2'] = annotations['comments'].apply(limpiar_texto)

# Cantidad de caracteres de los comentarios limpios 2
annotations["len_comments_clean_2"] = annotations["comments_clean_2"].str.len()

# Limpiamos comentarios sin caracteres
annotations = annotations[annotations["len_comments_clean_2"]>0].reset_index(drop=True).copy()

annotations[['comments', 'comments_clean','comments_clean_2']].sample(10)

# A partir de los comentarios de la 'primera limpieza'

# Crear el objeto WordCloud 
all_comments = ' '.join(annotations['comments_clean'])
wordcloud = WordCloud(width=800, height=400, background_color='white').generate(all_comments)

# Mostrar nube de palabras
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

# A partir de los comentarios de la 'segunda limpieza' (sin stopwords)

# Crear el objeto WordCloud 
all_comments = ' '.join(annotations['comments_clean_2'])
wordcloud = WordCloud(width=800, height=400, background_color='white').generate(all_comments)

# Mostrar nube de palabras
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

from nltk.util import ngrams
from nltk import FreqDist

# Tokenizar y filtrar palabras irrelevantes usando spaCy
def tokenize(text):
    doc = nlp(text)
    return [token.text for token in doc]

comments = annotations['comments_clean_2'].tolist()
filtered_words = []
for comment in comments:
    words = tokenize(comment)  # tokenizar
    filtered_words.extend(words)
    
    
# Generar bigramas y trigramas
bigrams = ngrams(filtered_words, 2)
trigrams = ngrams(filtered_words, 3)

# Contar frecuencia de bigramas y trigramas
bigram_freq = FreqDist(bigrams)
trigram_freq = FreqDist(trigrams)

# Crear un diccionario de palabras compuestas con sus frecuencias
composite_words = {f"{k[0]} {k[1]}": v for k, v in bigram_freq.items()}
composite_words.update({f"{k[0]} {k[1]} {k[2]}": v for k, v in trigram_freq.items()})

# Crear una nube de palabras
wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies(composite_words)

# Mostrar la nube de palabras
plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()

# Convertir bigram_freq a un DataFrame de pandas
bigram_data = pd.DataFrame(bigram_freq.items(), columns=['Bigram', 'Frequency'])

# Expandir los bigramas en dos columnas separadas
bigram_data[['Bigram1', 'Bigram2']] = pd.DataFrame(bigram_data['Bigram'].tolist(), index=bigram_data.index)

# Eliminar la columna original del bigrama
bigram_data = bigram_data.drop(columns=['Bigram'])

# Mostrar top 15
bigram_data.sort_values("Frequency", ascending=False).head(15)

# Convertir trigram_freq a un DataFrame de pandas
trigram_data = pd.DataFrame(trigram_freq.items(), columns=['Trigram', 'Frequency'])

# Expandir los trigramas en tres columnas separadas
trigram_data[['Bigram1', 'Bigram2', 'Bigram3']] = pd.DataFrame(trigram_data['Trigram'].tolist(), index=trigram_data.index)

# Eliminar la columna original del trigrama
trigram_data = trigram_data.drop(columns=['Trigram'])

# Mostrar top 15
trigram_data.sort_values("Frequency", ascending=False).head(15)

# Diccionario indicadores
indicadores = pd.read_csv('../data/id_indicadores.csv')
selected_columns = ['phenomenon_name', 'phenomenon_scientific_name', 'phenomenon_category_name']
indicadores = indicadores[selected_columns]

# Primeros registros
indicadores.head()

# Diccionario productos
productos = pd.read_excel('../data/id_productos.xlsx')
selected_columns = ['PRODUCTO', 'PRINCIPIO_ACTIVO', 'GRUPO']
productos = productos[selected_columns]

# Primeros registros
productos.head()

# Aplicamos la misma limpieza a los diccionarios como hicimos con los comentarios
indicadores['phenomenon_name'] = indicadores['phenomenon_name'].apply(limpiar_texto)
indicadores['phenomenon_category_name'] = indicadores['phenomenon_category_name'].apply(limpiar_texto)
indicadores['phenomenon_scientific_name'] = indicadores['phenomenon_scientific_name'].apply(limpiar_texto)

productos['PRODUCTO'] = productos['PRODUCTO'].apply(limpiar_texto)
productos['PRINCIPIO_ACTIVO'] = productos['PRINCIPIO_ACTIVO'].apply(limpiar_texto)
productos['GRUPO'] = productos['GRUPO'].apply(limpiar_texto)

# Crear un nuevo DataFrame con las columnas 'phrase' y 'tag' a partir de los DataFrames 'indicadores' y 'productos'
df_indicadores = pd.DataFrame({
    'phrase': pd.concat([indicadores['phenomenon_name'], indicadores['phenomenon_scientific_name']]),
    'tag': pd.concat([indicadores['phenomenon_category_name'], indicadores['phenomenon_category_name']])
})

df_productos = pd.DataFrame({
    'phrase': pd.concat([productos['PRODUCTO'], productos['PRINCIPIO_ACTIVO']]),
    'tag': pd.concat([productos['GRUPO'], productos['GRUPO']])
})

# Unir ambos DataFrames
df_combined = pd.concat([df_indicadores, df_productos], ignore_index=True)

# Mostrar el nuevo DataFrame
df_combined.head()

df_combined[df_combined['phrase'].str.contains('maleza')]

# incluimos el tag como phrase

# Duplicar las filas y cambiar los valores en la columna 'phrase' en las filas duplicadas
df_duplicado = df_combined.copy()
df_duplicado['phrase'] = df_duplicado['tag']
df_duplicado = df_duplicado.drop_duplicates().reset_index(drop=True)

# Concatenar el DataFrame original con el duplicado
df_combined = pd.concat([df_combined, df_duplicado], ignore_index=True)

df_combined[df_combined['phrase'].str.contains('maleza')]

df_combined["tag"].value_counts()

# euclidean distances
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import euclidean_distances

# Top 1000 bigramas
top_bigrams = (bigram_data.sort_values(by='Frequency', ascending=False)
                          .head(1000)['Bigram1'] + ' ' + bigram_data.sort_values(by='Frequency', ascending=False)
                          .head(1000)['Bigram2']).tolist()

# Combinamos texto
all_text = top_bigrams + df_combined['phrase'].tolist()

# Vectorizamos texto
vectorizer = TfidfVectorizer().fit(all_text)
bigram_vectors = vectorizer.transform(top_bigrams)
phrase_vectors = vectorizer.transform(df_combined['phrase'])

# Calculamos distancia
distance_matrix = euclidean_distances(bigram_vectors, phrase_vectors)

# Asignamos tags en base a las distanicas
tags = []
scores = []
phrases = []
for i, bigram in enumerate(top_bigrams):
    # Obtenemos indice de la menor distancia
    most_similar_index = distance_matrix[i].argmin()
    # Obtenemos el tag asociado al indice
    phrase = df_combined.iloc[most_similar_index]['phrase']
    tag = df_combined.iloc[most_similar_index]['tag']
    score = distance_matrix[i][most_similar_index]
    tags.append(tag)
    scores.append(score)
    phrases.append(phrase)

# Creamos dataframe con los resultados
results_df_eucl_dist = pd.DataFrame({
    'Bigram': top_bigrams,
    'Tag': tags,
    'Phrase': phrases,
    'Score': scores
})

# Display the DataFrame
results_df_eucl_dist.sort_values(by='Score').head(100)

# similaridad coseno
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Top 1000 bigramas
top_bigrams = (bigram_data.sort_values(by='Frequency', ascending=False)
                          .head(1000)['Bigram1'] + ' ' + bigram_data.sort_values(by='Frequency', ascending=False)
                          .head(1000)['Bigram2']).tolist()

# Combinamos texto
all_text = top_bigrams + df_combined['phrase'].tolist()

# Vectorizamos texto
vectorizer = TfidfVectorizer().fit(all_text)
bigram_vectors = vectorizer.transform(top_bigrams)
phrase_vectors = vectorizer.transform(df_combined['phrase'])

# Calculamos similaridad coseno
distance_matrix = cosine_similarity(bigram_vectors, phrase_vectors)

# Asignamos tags en base a las distanicas
tags = []
scores = []
phrases = []
for i, bigram in enumerate(top_bigrams):
    # Obtenemos indice de la menor distancia
    most_similar_index = distance_matrix[i].argmax()
    # Obtenemos el tag asociado al indice
    phrase = df_combined.iloc[most_similar_index]['phrase']
    tag = df_combined.iloc[most_similar_index]['tag']
    score = distance_matrix[i][most_similar_index]
    tags.append(tag)
    scores.append(score)
    phrases.append(phrase)

# Creamos dataframe con los resultados
results_df_coseno_sim = pd.DataFrame({
    'Bigram': top_bigrams,
    'Tag': tags,
    'Phrase': phrases,
    'Score': scores
})

# Display the DataFrame
results_df_coseno_sim.sort_values(by='Score', ascending=False).head(100)

#Distancia de Levenshtein
import pandas as pd
import numpy as np
from Levenshtein import distance as levenshtein_distance

# Armamos lista de bigramas - TOP BIGRAMAS?
bigrams_list = (bigram_data.sort_values(by='Frequency', ascending=False)['Bigram1'] + ' ' + bigram_data.sort_values(by='Frequency', ascending=False)['Bigram2']).tolist()

# Definimos función para calcular la distancia de Levenshtein entre dos listas de strings
def levenshtein_distances(list1, list2):
    distances = np.zeros((len(list1), len(list2)))
    for i, s1 in enumerate(list1):
        for j, s2 in enumerate(list2):
            distances[i, j] = levenshtein_distance(s1, s2) / len(s1)
    return distances

# Calculamos distancias de Levenshtein
distance_matrix = levenshtein_distances(bigrams_list, df_combined['phrase'])

# Asignamos el 'tag' del diccionario a partir de 'phrase'
tags = []
scores = []
phrases = []
for i, bigram in enumerate(bigrams_list):
    # Index 'phrase' con menor distancia
    most_similar_index = distance_matrix[i].argmin()
    # Obtener el 'tag' a partir del index y la 'distancia'
    phrase = df_combined.iloc[most_similar_index]['phrase']
    tag = df_combined.iloc[most_similar_index]['tag']
    score = distance_matrix[i][most_similar_index]
    tags.append(tag)
    scores.append(score)
    phrases.append(phrase)

# Guardamos los resultados en un dataframe
results_df = pd.DataFrame({
    'Bigram': bigrams_list,
    'Tag': tags,
    'Phrase': phrases,
    'Score': scores
})

# Ver resultados
results_df.sort_values(by='Score').head(100)

results_df_2 = results_df.copy()
results_df_2["Score"] = round(results_df_2["Score"],2)
results_df_2.columns = ["Bigram","Phrase","Tag","Score"]
results_df_2.sort_values(by='Score').head(300).sample(15, random_state=15).sort_values("Score")

# distribución Score
results_df["Score"].describe()

results_df["Score"].hist()

# filtrando scores menores a 0.4
score_max = 0.42
results_df_filtrado = results_df[results_df["Score"]<score_max].reset_index(drop=True)
results_df_filtrado.sort_values(by='Score')

# Guardamos resultado Levenshtein para etiquetar
if SAVE_NOTEBOOK_RESULTS:
    results_df_filtrado.to_csv("Workflow_output/results_df_filtrado.csv", index=False)

# Guardamos resultado Levenshtein sin punto de corte (sin filtrar)
if SAVE_NOTEBOOK_RESULTS:
    results_df.to_csv("Workflow_output/results_df.csv", index=False)

# definimos función para matchear los tags de los bigramas con los comentarios
def find_all_tags(comment, phrase_to_tag):
    return [tag for phrase, tag in phrase_to_tag.items() if phrase in comment.lower()]

# aplicamos
# crear un diccionario de bigramas y phrases
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Phrase']))
annotations['comment_phrases'] = annotations['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# crear un diccionario de bigramas y scores
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Score']))
annotations['comment_scores'] = annotations['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# crear un diccionario de bigramas y tags
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Tag']))
annotations['comment_tags'] = annotations['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# Función para obtener el tag o score con el mayor valor (o 'sin etiquetar' si la lista está vacía)
def get_max_value(row, value_type='tag'):
    if row['comment_scores']:  # Verificamos si la lista no está vacía
        max_score_index = row['comment_scores'].index(min(row['comment_scores']))  # O min si quieres el valor más bajo
        return row['comment_tags'][max_score_index] if value_type == 'tag' else row['comment_scores'][max_score_index]
    else:
        return 'sin etiquetar'  # Devuelve 'sin etiquetar' si la lista de scores está vacía

# Aplicamos la función al DataFrame para tags
annotations['best_tag'] = annotations.apply(lambda row: get_max_value(row, 'tag'), axis=1)

# Aplicamos la función al DataFrame para scores
annotations['best_score'] = annotations.apply(lambda row: get_max_value(row, 'score'), axis=1)

# distribución de los tags imputados a partir de los comentarios
annotations['best_tag'].value_counts(dropna=False, normalize=True).head(6).round(2)

annotations#[annotations['best_tag']=="plagas"]

# Guardamos base para modelo
if SAVE_NOTEBOOK_RESULTS:
    annotations.to_csv(file_with_tags, index=False)

annotations = pd.read_csv(file_with_tags)

# preparar base
condicion = (annotations["best_tag"].isin(["malezas","enfermedades","plagas","fungicida","general lote"]))
campos_interes = ["comments_clean_2", "best_tag"]#, "comments_clean","comments_clean_2","best_score"]
df_model = annotations[condicion][campos_interes].reset_index(drop=True)
df_model

import nltk
from nltk.classify import NaiveBayesClassifier, MaxentClassifier, SklearnClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report, accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer

X = df_model['comments_clean_2']
y = df_model['best_tag']

# Dividir en conjunto de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Vectorización de texto con TF-IDF
vectorizer = TfidfVectorizer(max_features=5000)
X_train_tfidf = vectorizer.fit_transform(X_train).toarray()
X_test_tfidf = vectorizer.transform(X_test).toarray()

# Crear pares de características y etiquetas para nltk
train_data = [(dict(enumerate(x)), label) for x, label in zip(X_train_tfidf, y_train)]
test_data = [(dict(enumerate(x)), label) for x, label in zip(X_test_tfidf, y_test)]

# Naive Bayes Classifier
print("Naive Bayes Classifier")
nb_classifier = NaiveBayesClassifier.train(train_data)
nb_accuracy = nltk.classify.accuracy(nb_classifier, test_data)
print("Naive Bayes Accuracy:", nb_accuracy)

# Maxent Classifier (requiere el algoritmo GIS)
print("Maxent Classifier")
maxent_classifier = MaxentClassifier.train(train_data, algorithm='gis', max_iter=4)#, trace=0, max_iter=3, min_lldelta=0.5)#, algorithm='gis', max_iter=10)
maxent_accuracy = nltk.classify.accuracy(maxent_classifier, test_data)
print("Maxent Classifier Accuracy:", maxent_accuracy)

# SklearnClassifier con Logistic Regression
#print("SklearnClassifier")
sklearn_classifier = SklearnClassifier(MultinomialNB()).train(train_data)
sklearn_accuracy = nltk.classify.accuracy(sklearn_classifier, test_data)
print("MultinomialNB (SklearnClassifier) Accuracy:", sklearn_accuracy)

# Generar reporte detallado
nb_classifier_model = nb_classifier  # puedes elegir el mejor clasificador
y_pred_nb_classifier = [nb_classifier_model.classify(dict(enumerate(vectorizer.transform([comment]).toarray()[0]))) for comment in X_test]

maxent_classifier_model = maxent_classifier  # puedes elegir el mejor clasificador
y_pred_maxent_classifier = [maxent_classifier_model.classify(dict(enumerate(vectorizer.transform([comment]).toarray()[0]))) for comment in X_test]


sklearn_classifier_model = sklearn_classifier  # puedes elegir el mejor clasificador
y_pred_sklearn_classifier = [sklearn_classifier_model.classify(dict(enumerate(vectorizer.transform([comment]).toarray()[0]))) for comment in X_test]

df_test = pd.DataFrame({"y_test":y_test,"y_pred_nb_classifier":y_pred_nb_classifier,"y_pred_maxent_classifier":y_pred_maxent_classifier, "y_pred_sklearn_classifier":y_pred_sklearn_classifier})
df_test

print(df_test["y_test"].value_counts())
print(df_test["y_pred_nb_classifier"].value_counts())
print(df_test["y_pred_maxent_classifier"].value_counts())
print(df_test["y_pred_sklearn_classifier"].value_counts())

#df_test[df_test["y_pred_sklearn_classifier"]=="enfermedades"]

print("\nClassification Report:\n", classification_report(df_test["y_test"], df_test["y_pred_maxent_classifier"]))

print("\nClassification Report:\n", classification_report(df_test["y_test"], df_test["y_pred_nb_classifier"]))

print("\nClassification Report:\n", classification_report(df_test["y_test"], df_test["y_pred_sklearn_classifier"]))

df_validation = pd.read_csv('../data/validation.csv', encoding='ISO-8859-1')

# limpieza
df_validation.loc[df_validation["specialist_tag"]=="maleza","specialist_tag"] = "malezas"
df_validation.loc[df_validation["specialist_tag"]=="plaga","specialist_tag"] = "plagas"
df_validation = df_validation[~df_validation["specialist_tag"].isna()].copy().reset_index(drop=True)

# filtramos etiquetas de interes
df_validation_filtrada = df_validation[df_validation["specialist_tag"].isin(['malezas','plagas','enfermedades','herbicida','fungicida','insecticida'])].copy().reset_index(drop=True)

df_validation_filtrada.head()

df_validation_filtrada.specialist_tag.value_counts()

# aplicamos modelo vs clasificador
# procesamiento
df_validation_filtrada['comments_clean_2'] = df_validation_filtrada['comments'].apply(limpiar_texto)

# aplicamos clasificador con diccionario
# crear un diccionario de bigramas y phrases
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Phrase']))
df_validation_filtrada['comment_phrases'] = df_validation_filtrada['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# crear un diccionario de bigramas y scores
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Score']))
df_validation_filtrada['comment_scores'] = df_validation_filtrada['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# crear un diccionario de bigramas y tags
phrase_to_tag = dict(zip(results_df_filtrado['Bigram'].str.lower(), results_df_filtrado['Tag']))
df_validation_filtrada['comment_tags'] = df_validation_filtrada['comments_clean_2'].apply(lambda comment: find_all_tags(comment, phrase_to_tag))

# Aplicamos la función al DataFrame para tags
df_validation_filtrada['best_tag'] = df_validation_filtrada.apply(lambda row: get_max_value(row, 'tag'), axis=1)

# Aplicamos la función al DataFrame para scores
df_validation_filtrada['best_score'] = df_validation_filtrada.apply(lambda row: get_max_value(row, 'score'), axis=1)

# aplicamos modelo
y_pred_sklearn_classifier = [sklearn_classifier_model.classify(dict(enumerate(vectorizer.transform([comment]).toarray()[0]))) for comment in df_validation_filtrada['comments_clean_2']]

df_validation_filtrada["y_pred_sklearn_classifier"] = y_pred_sklearn_classifier

print("\nClassification Report:\n", classification_report(df_validation_filtrada["specialist_tag"], df_validation_filtrada["best_tag"]))

print("\nClassification Report:\n", classification_report(df_validation_filtrada["specialist_tag"], df_validation_filtrada["y_pred_sklearn_classifier"]))